/*
 * Copyright (c) 1997, 2013, Oracle and/or its affiliates. All rights reserved.
 * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 */
package javax.swing.text;

import java.io.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.beans.PropertyChangeEvent;
import java.beans.PropertyChangeListener;
import javax.swing.event.*;
import javax.swing.Action;
import javax.swing.JEditorPane;
import javax.swing.KeyStroke;
import javax.swing.UIManager;

/**
 * This is the set of things needed by a text component
 * to be a reasonably functioning editor for some <em>type</em>
 * of text document.  This implementation provides a default
 * implementation which treats text as styled text and
 * provides a minimal set of actions for editing styled text.
 *
 * @author Timothy Prinzing
 */
public class StyledEditorKit extends DefaultEditorKit {

  /**
   * Creates a new EditorKit used for styled documents.
   */
  public StyledEditorKit() {
    createInputAttributeUpdated();
    createInputAttributes();
  }

  /**
   * Gets the input attributes for the pane.  When
   * the caret moves and there is no selection, the
   * input attributes are automatically mutated to
   * reflect the character attributes of the current
   * caret location.  The styled editing actions
   * use the input attributes to carry out their
   * actions.
   *
   * @return the attribute set
   */
  public MutableAttributeSet getInputAttributes() {
    return inputAttributes;
  }

  /**
   * Fetches the element representing the current
   * run of character attributes for the caret.
   *
   * @return the element
   */
  public Element getCharacterAttributeRun() {
    return currentRun;
  }

  // --- EditorKit methods ---------------------------

  /**
   * Fetches the command list for the editor.  This is
   * the list of commands supported by the superclass
   * augmented by the collection of commands defined
   * locally for style operations.
   *
   * @return the command list
   */
  public Action[] getActions() {
    return TextAction.augmentList(super.getActions(), this.defaultActions);
  }

  /**
   * Creates an uninitialized text storage model
   * that is appropriate for this type of editor.
   *
   * @return the model
   */
  public Document createDefaultDocument() {
    return new DefaultStyledDocument();
  }

  /**
   * Called when the kit is being installed into
   * a JEditorPane.
   *
   * @param c the JEditorPane
   */
  public void install(JEditorPane c) {
    c.addCaretListener(inputAttributeUpdater);
    c.addPropertyChangeListener(inputAttributeUpdater);
    Caret caret = c.getCaret();
    if (caret != null) {
      inputAttributeUpdater.updateInputAttributes
          (caret.getDot(), caret.getMark(), c);
    }
  }

  /**
   * Called when the kit is being removed from the
   * JEditorPane.  This is used to unregister any
   * listeners that were attached.
   *
   * @param c the JEditorPane
   */
  public void deinstall(JEditorPane c) {
    c.removeCaretListener(inputAttributeUpdater);
    c.removePropertyChangeListener(inputAttributeUpdater);

    // remove references to current document so it can be collected.
    currentRun = null;
    currentParagraph = null;
  }

  /**
   * Fetches a factory that is suitable for producing
   * views of any models that are produced by this
   * kit.  This is implemented to return View implementations
   * for the following kinds of elements:
   * <ul>
   * <li>AbstractDocument.ContentElementName
   * <li>AbstractDocument.ParagraphElementName
   * <li>AbstractDocument.SectionElementName
   * <li>StyleConstants.ComponentElementName
   * <li>StyleConstants.IconElementName
   * </ul>
   *
   * @return the factory
   */
  public ViewFactory getViewFactory() {
    return defaultFactory;
  }

  /**
   * Creates a copy of the editor kit.
   *
   * @return the copy
   */
  public Object clone() {
    StyledEditorKit o = (StyledEditorKit) super.clone();
    o.currentRun = o.currentParagraph = null;
    o.createInputAttributeUpdated();
    o.createInputAttributes();
    return o;
  }

  /**
   * Creates the AttributeSet used for the selection.
   */
  private void createInputAttributes() {
    inputAttributes = new SimpleAttributeSet() {
      public AttributeSet getResolveParent() {
        return (currentParagraph != null) ?
            currentParagraph.getAttributes() : null;
      }

      public Object clone() {
        return new SimpleAttributeSet(this);
      }
    };
  }

  /**
   * Creates a new <code>AttributeTracker</code>.
   */
  private void createInputAttributeUpdated() {
    inputAttributeUpdater = new AttributeTracker();
  }


  private static final ViewFactory defaultFactory = new StyledViewFactory();

  Element currentRun;
  Element currentParagraph;

  /**
   * This is the set of attributes used to store the
   * input attributes.
   */
  MutableAttributeSet inputAttributes;

  /**
   * This listener will be attached to the caret of
   * the text component that the EditorKit gets installed
   * into.  This should keep the input attributes updated
   * for use by the styled actions.
   */
  private AttributeTracker inputAttributeUpdater;

  /**
   * Tracks caret movement and keeps the input attributes set
   * to reflect the current set of attribute definitions at the
   * caret position.
   * <p>This implements PropertyChangeListener to update the
   * input attributes when the Document changes, as if the Document
   * changes the attributes will almost certainly change.
   */
  class AttributeTracker implements CaretListener, PropertyChangeListener, Serializable {

    /**
     * Updates the attributes. <code>dot</code> and <code>mark</code>
     * mark give the positions of the selection in <code>c</code>.
     */
    void updateInputAttributes(int dot, int mark, JTextComponent c) {
      // EditorKit might not have installed the StyledDocument yet.
      Document aDoc = c.getDocument();
      if (!(aDoc instanceof StyledDocument)) {
        return;
      }
      int start = Math.min(dot, mark);
      // record current character attributes.
      StyledDocument doc = (StyledDocument) aDoc;
      // If nothing is selected, get the attributes from the character
      // before the start of the selection, otherwise get the attributes
      // from the character element at the start of the selection.
      Element run;
      currentParagraph = doc.getParagraphElement(start);
      if (currentParagraph.getStartOffset() == start || dot != mark) {
        // Get the attributes from the character at the selection
        // if in a different paragrah!
        run = doc.getCharacterElement(start);
      } else {
        run = doc.getCharacterElement(Math.max(start - 1, 0));
      }
      if (run != currentRun) {
                    /*
                     * PENDING(prinz) All attributes that represent a single
                     * glyph position and can't be inserted into should be
                     * removed from the input attributes... this requires
                     * mixing in an interface to indicate that condition.
                     * When we can add things again this logic needs to be
                     * improved!!
                     */
        currentRun = run;
        createInputAttributes(currentRun, getInputAttributes());
      }
    }

    public void propertyChange(PropertyChangeEvent evt) {
      Object newValue = evt.getNewValue();
      Object source = evt.getSource();

      if ((source instanceof JTextComponent) &&
          (newValue instanceof Document)) {
        // New document will have changed selection to 0,0.
        updateInputAttributes(0, 0, (JTextComponent) source);
      }
    }

    public void caretUpdate(CaretEvent e) {
      updateInputAttributes(e.getDot(), e.getMark(),
          (JTextComponent) e.getSource());
    }
  }

  /**
   * Copies the key/values in <code>element</code>s AttributeSet into
   * <code>set</code>. This does not copy component, icon, or element
   * names attributes. Subclasses may wish to refine what is and what
   * isn't copied here. But be sure to first remove all the attributes that
   * are in <code>set</code>.<p>
   * This is called anytime the caret moves over a different location.
   */
  protected void createInputAttributes(Element element,
      MutableAttributeSet set) {
    if (element.getAttributes().getAttributeCount() > 0
        || element.getEndOffset() - element.getStartOffset() > 1
        || element.getEndOffset() < element.getDocument().getLength()) {
      set.removeAttributes(set);
      set.addAttributes(element.getAttributes());
      set.removeAttribute(StyleConstants.ComponentAttribute);
      set.removeAttribute(StyleConstants.IconAttribute);
      set.removeAttribute(AbstractDocument.ElementNameAttribute);
      set.removeAttribute(StyleConstants.ComposedTextAttribute);
    }
  }

  // ---- default ViewFactory implementation ---------------------

  static class StyledViewFactory implements ViewFactory {

    public View create(Element elem) {
      String kind = elem.getName();
      if (kind != null) {
        if (kind.equals(AbstractDocument.ContentElementName)) {
          return new LabelView(elem);
        } else if (kind.equals(AbstractDocument.ParagraphElementName)) {
          return new ParagraphView(elem);
        } else if (kind.equals(AbstractDocument.SectionElementName)) {
          return new BoxView(elem, View.Y_AXIS);
        } else if (kind.equals(StyleConstants.ComponentElementName)) {
          return new ComponentView(elem);
        } else if (kind.equals(StyleConstants.IconElementName)) {
          return new IconView(elem);
        }
      }

      // default to text display
      return new LabelView(elem);
    }

  }

  // --- Action implementations ---------------------------------

  private static final Action[] defaultActions = {
      new FontFamilyAction("font-family-SansSerif", "SansSerif"),
      new FontFamilyAction("font-family-Monospaced", "Monospaced"),
      new FontFamilyAction("font-family-Serif", "Serif"),
      new FontSizeAction("font-size-8", 8),
      new FontSizeAction("font-size-10", 10),
      new FontSizeAction("font-size-12", 12),
      new FontSizeAction("font-size-14", 14),
      new FontSizeAction("font-size-16", 16),
      new FontSizeAction("font-size-18", 18),
      new FontSizeAction("font-size-24", 24),
      new FontSizeAction("font-size-36", 36),
      new FontSizeAction("font-size-48", 48),
      new AlignmentAction("left-justify", StyleConstants.ALIGN_LEFT),
      new AlignmentAction("center-justify", StyleConstants.ALIGN_CENTER),
      new AlignmentAction("right-justify", StyleConstants.ALIGN_RIGHT),
      new BoldAction(),
      new ItalicAction(),
      new StyledInsertBreakAction(),
      new UnderlineAction()
  };

  /**
   * An action that assumes it's being fired on a JEditorPane
   * with a StyledEditorKit (or subclass) installed.  This has
   * some convenience methods for causing character or paragraph
   * level attribute changes.  The convenience methods will
   * throw an IllegalArgumentException if the assumption of
   * a StyledDocument, a JEditorPane, or a StyledEditorKit
   * fail to be true.
   * <p>
   * The component that gets acted upon by the action
   * will be the source of the ActionEvent if the source
   * can be narrowed to a JEditorPane type.  If the source
   * can't be narrowed, the most recently focused text
   * component is changed.  If neither of these are the
   * case, the action cannot be performed.
   * <p>
   * <strong>Warning:</strong>
   * Serialized objects of this class will not be compatible with
   * future Swing releases. The current serialization support is
   * appropriate for short term storage or RMI between applications running
   * the same version of Swing.  As of 1.4, support for long term storage
   * of all JavaBeans&trade;
   * has been added to the <code>java.beans</code> package.
   * Please see {@link java.beans.XMLEncoder}.
   */
  public abstract static class StyledTextAction extends TextAction {

    /**
     * Creates a new StyledTextAction from a string action name.
     *
     * @param nm the name of the action
     */
    public StyledTextAction(String nm) {
      super(nm);
    }

    /**
     * Gets the target editor for an action.
     *
     * @param e the action event
     * @return the editor
     */
    protected final JEditorPane getEditor(ActionEvent e) {
      JTextComponent tcomp = getTextComponent(e);
      if (tcomp instanceof JEditorPane) {
        return (JEditorPane) tcomp;
      }
      return null;
    }

    /**
     * Gets the document associated with an editor pane.
     *
     * @param e the editor
     * @return the document
     * @throws IllegalArgumentException for the wrong document type
     */
    protected final StyledDocument getStyledDocument(JEditorPane e) {
      Document d = e.getDocument();
      if (d instanceof StyledDocument) {
        return (StyledDocument) d;
      }
      throw new IllegalArgumentException("document must be StyledDocument");
    }

    /**
     * Gets the editor kit associated with an editor pane.
     *
     * @param e the editor pane
     * @return the kit
     * @throws IllegalArgumentException for the wrong document type
     */
    protected final StyledEditorKit getStyledEditorKit(JEditorPane e) {
      EditorKit k = e.getEditorKit();
      if (k instanceof StyledEditorKit) {
        return (StyledEditorKit) k;
      }
      throw new IllegalArgumentException("EditorKit must be StyledEditorKit");
    }

    /**
     * Applies the given attributes to character
     * content.  If there is a selection, the attributes
     * are applied to the selection range.  If there
     * is no selection, the attributes are applied to
     * the input attribute set which defines the attributes
     * for any new text that gets inserted.
     *
     * @param editor the editor
     * @param attr the attributes
     * @param replace if true, then replace the existing attributes first
     */
    protected final void setCharacterAttributes(JEditorPane editor,
        AttributeSet attr, boolean replace) {
      int p0 = editor.getSelectionStart();
      int p1 = editor.getSelectionEnd();
      if (p0 != p1) {
        StyledDocument doc = getStyledDocument(editor);
        doc.setCharacterAttributes(p0, p1 - p0, attr, replace);
      }
      StyledEditorKit k = getStyledEditorKit(editor);
      MutableAttributeSet inputAttributes = k.getInputAttributes();
      if (replace) {
        inputAttributes.removeAttributes(inputAttributes);
      }
      inputAttributes.addAttributes(attr);
    }

    /**
     * Applies the given attributes to paragraphs.  If
     * there is a selection, the attributes are applied
     * to the paragraphs that intersect the selection.
     * if there is no selection, the attributes are applied
     * to the paragraph at the current caret position.
     *
     * @param editor the editor
     * @param attr the attributes
     * @param replace if true, replace the existing attributes first
     */
    protected final void setParagraphAttributes(JEditorPane editor,
        AttributeSet attr, boolean replace) {
      int p0 = editor.getSelectionStart();
      int p1 = editor.getSelectionEnd();
      StyledDocument doc = getStyledDocument(editor);
      doc.setParagraphAttributes(p0, p1 - p0, attr, replace);
    }

  }

  /**
   * An action to set the font family in the associated
   * JEditorPane.  This will use the family specified as
   * the command string on the ActionEvent if there is one,
   * otherwise the family that was initialized with will be used.
   * <p>
   * <strong>Warning:</strong>
   * Serialized objects of this class will not be compatible with
   * future Swing releases. The current serialization support is
   * appropriate for short term storage or RMI between applications running
   * the same version of Swing.  As of 1.4, support for long term storage
   * of all JavaBeans&trade;
   * has been added to the <code>java.beans</code> package.
   * Please see {@link java.beans.XMLEncoder}.
   */
  public static class FontFamilyAction extends StyledTextAction {

    /**
     * Creates a new FontFamilyAction.
     *
     * @param nm the action name
     * @param family the font family
     */
    public FontFamilyAction(String nm, String family) {
      super(nm);
      this.family = family;
    }

    /**
     * Sets the font family.
     *
     * @param e the event
     */
    public void actionPerformed(ActionEvent e) {
      JEditorPane editor = getEditor(e);
      if (editor != null) {
        String family = this.family;
        if ((e != null) && (e.getSource() == editor)) {
          String s = e.getActionCommand();
          if (s != null) {
            family = s;
          }
        }
        if (family != null) {
          MutableAttributeSet attr = new SimpleAttributeSet();
          StyleConstants.setFontFamily(attr, family);
          setCharacterAttributes(editor, attr, false);
        } else {
          UIManager.getLookAndFeel().provideErrorFeedback(editor);
        }
      }
    }

    private String family;
  }

  /**
   * An action to set the font size in the associated
   * JEditorPane.  This will use the size specified as
   * the command string on the ActionEvent if there is one,
   * otherwise the size that was initialized with will be used.
   * <p>
   * <strong>Warning:</strong>
   * Serialized objects of this class will not be compatible with
   * future Swing releases. The current serialization support is
   * appropriate for short term storage or RMI between applications running
   * the same version of Swing.  As of 1.4, support for long term storage
   * of all JavaBeans&trade;
   * has been added to the <code>java.beans</code> package.
   * Please see {@link java.beans.XMLEncoder}.
   */
  public static class FontSizeAction extends StyledTextAction {

    /**
     * Creates a new FontSizeAction.
     *
     * @param nm the action name
     * @param size the font size
     */
    public FontSizeAction(String nm, int size) {
      super(nm);
      this.size = size;
    }

    /**
     * Sets the font size.
     *
     * @param e the action event
     */
    public void actionPerformed(ActionEvent e) {
      JEditorPane editor = getEditor(e);
      if (editor != null) {
        int size = this.size;
        if ((e != null) && (e.getSource() == editor)) {
          String s = e.getActionCommand();
          try {
            size = Integer.parseInt(s, 10);
          } catch (NumberFormatException nfe) {
          }
        }
        if (size != 0) {
          MutableAttributeSet attr = new SimpleAttributeSet();
          StyleConstants.setFontSize(attr, size);
          setCharacterAttributes(editor, attr, false);
        } else {
          UIManager.getLookAndFeel().provideErrorFeedback(editor);
        }
      }
    }

    private int size;
  }

  /**
   * An action to set foreground color.  This sets the
   * <code>StyleConstants.Foreground</code> attribute for the
   * currently selected range of the target JEditorPane.
   * This is done by calling
   * <code>StyledDocument.setCharacterAttributes</code>
   * on the styled document associated with the target
   * JEditorPane.
   * <p>
   * If the target text component is specified as the
   * source of the ActionEvent and there is a command string,
   * the command string will be interpreted as the foreground
   * color.  It will be interpreted by called
   * <code>Color.decode</code>, and should therefore be
   * legal input for that method.
   * <p>
   * <strong>Warning:</strong>
   * Serialized objects of this class will not be compatible with
   * future Swing releases. The current serialization support is
   * appropriate for short term storage or RMI between applications running
   * the same version of Swing.  As of 1.4, support for long term storage
   * of all JavaBeans&trade;
   * has been added to the <code>java.beans</code> package.
   * Please see {@link java.beans.XMLEncoder}.
   */
  public static class ForegroundAction extends StyledTextAction {

    /**
     * Creates a new ForegroundAction.
     *
     * @param nm the action name
     * @param fg the foreground color
     */
    public ForegroundAction(String nm, Color fg) {
      super(nm);
      this.fg = fg;
    }

    /**
     * Sets the foreground color.
     *
     * @param e the action event
     */
    public void actionPerformed(ActionEvent e) {
      JEditorPane editor = getEditor(e);
      if (editor != null) {
        Color fg = this.fg;
        if ((e != null) && (e.getSource() == editor)) {
          String s = e.getActionCommand();
          try {
            fg = Color.decode(s);
          } catch (NumberFormatException nfe) {
          }
        }
        if (fg != null) {
          MutableAttributeSet attr = new SimpleAttributeSet();
          StyleConstants.setForeground(attr, fg);
          setCharacterAttributes(editor, attr, false);
        } else {
          UIManager.getLookAndFeel().provideErrorFeedback(editor);
        }
      }
    }

    private Color fg;
  }

  /**
   * An action to set paragraph alignment.  This sets the
   * <code>StyleConstants.Alignment</code> attribute for the
   * currently selected range of the target JEditorPane.
   * This is done by calling
   * <code>StyledDocument.setParagraphAttributes</code>
   * on the styled document associated with the target
   * JEditorPane.
   * <p>
   * If the target text component is specified as the
   * source of the ActionEvent and there is a command string,
   * the command string will be interpreted as an integer
   * that should be one of the legal values for the
   * <code>StyleConstants.Alignment</code> attribute.
   * <p>
   * <strong>Warning:</strong>
   * Serialized objects of this class will not be compatible with
   * future Swing releases. The current serialization support is
   * appropriate for short term storage or RMI between applications running
   * the same version of Swing.  As of 1.4, support for long term storage
   * of all JavaBeans&trade;
   * has been added to the <code>java.beans</code> package.
   * Please see {@link java.beans.XMLEncoder}.
   */
  public static class AlignmentAction extends StyledTextAction {

    /**
     * Creates a new AlignmentAction.
     *
     * @param nm the action name
     * @param a the alignment &gt;= 0
     */
    public AlignmentAction(String nm, int a) {
      super(nm);
      this.a = a;
    }

    /**
     * Sets the alignment.
     *
     * @param e the action event
     */
    public void actionPerformed(ActionEvent e) {
      JEditorPane editor = getEditor(e);
      if (editor != null) {
        int a = this.a;
        if ((e != null) && (e.getSource() == editor)) {
          String s = e.getActionCommand();
          try {
            a = Integer.parseInt(s, 10);
          } catch (NumberFormatException nfe) {
          }
        }
        MutableAttributeSet attr = new SimpleAttributeSet();
        StyleConstants.setAlignment(attr, a);
        setParagraphAttributes(editor, attr, false);
      }
    }

    private int a;
  }

  /**
   * An action to toggle the bold attribute.
   * <p>
   * <strong>Warning:</strong>
   * Serialized objects of this class will not be compatible with
   * future Swing releases. The current serialization support is
   * appropriate for short term storage or RMI between applications running
   * the same version of Swing.  As of 1.4, support for long term storage
   * of all JavaBeans&trade;
   * has been added to the <code>java.beans</code> package.
   * Please see {@link java.beans.XMLEncoder}.
   */
  public static class BoldAction extends StyledTextAction {

    /**
     * Constructs a new BoldAction.
     */
    public BoldAction() {
      super("font-bold");
    }

    /**
     * Toggles the bold attribute.
     *
     * @param e the action event
     */
    public void actionPerformed(ActionEvent e) {
      JEditorPane editor = getEditor(e);
      if (editor != null) {
        StyledEditorKit kit = getStyledEditorKit(editor);
        MutableAttributeSet attr = kit.getInputAttributes();
        boolean bold = (StyleConstants.isBold(attr)) ? false : true;
        SimpleAttributeSet sas = new SimpleAttributeSet();
        StyleConstants.setBold(sas, bold);
        setCharacterAttributes(editor, sas, false);
      }
    }
  }

  /**
   * An action to toggle the italic attribute.
   * <p>
   * <strong>Warning:</strong>
   * Serialized objects of this class will not be compatible with
   * future Swing releases. The current serialization support is
   * appropriate for short term storage or RMI between applications running
   * the same version of Swing.  As of 1.4, support for long term storage
   * of all JavaBeans&trade;
   * has been added to the <code>java.beans</code> package.
   * Please see {@link java.beans.XMLEncoder}.
   */
  public static class ItalicAction extends StyledTextAction {

    /**
     * Constructs a new ItalicAction.
     */
    public ItalicAction() {
      super("font-italic");
    }

    /**
     * Toggles the italic attribute.
     *
     * @param e the action event
     */
    public void actionPerformed(ActionEvent e) {
      JEditorPane editor = getEditor(e);
      if (editor != null) {
        StyledEditorKit kit = getStyledEditorKit(editor);
        MutableAttributeSet attr = kit.getInputAttributes();
        boolean italic = (StyleConstants.isItalic(attr)) ? false : true;
        SimpleAttributeSet sas = new SimpleAttributeSet();
        StyleConstants.setItalic(sas, italic);
        setCharacterAttributes(editor, sas, false);
      }
    }
  }

  /**
   * An action to toggle the underline attribute.
   * <p>
   * <strong>Warning:</strong>
   * Serialized objects of this class will not be compatible with
   * future Swing releases. The current serialization support is
   * appropriate for short term storage or RMI between applications running
   * the same version of Swing.  As of 1.4, support for long term storage
   * of all JavaBeans&trade;
   * has been added to the <code>java.beans</code> package.
   * Please see {@link java.beans.XMLEncoder}.
   */
  public static class UnderlineAction extends StyledTextAction {

    /**
     * Constructs a new UnderlineAction.
     */
    public UnderlineAction() {
      super("font-underline");
    }

    /**
     * Toggles the Underline attribute.
     *
     * @param e the action event
     */
    public void actionPerformed(ActionEvent e) {
      JEditorPane editor = getEditor(e);
      if (editor != null) {
        StyledEditorKit kit = getStyledEditorKit(editor);
        MutableAttributeSet attr = kit.getInputAttributes();
        boolean underline = (StyleConstants.isUnderline(attr)) ? false : true;
        SimpleAttributeSet sas = new SimpleAttributeSet();
        StyleConstants.setUnderline(sas, underline);
        setCharacterAttributes(editor, sas, false);
      }
    }
  }


  /**
   * StyledInsertBreakAction has similar behavior to that of
   * <code>DefaultEditorKit.InsertBreakAction</code>. That is when
   * its <code>actionPerformed</code> method is invoked, a newline
   * is inserted. Beyond that, this will reset the input attributes to
   * what they were before the newline was inserted.
   */
  static class StyledInsertBreakAction extends StyledTextAction {

    private SimpleAttributeSet tempSet;

    StyledInsertBreakAction() {
      super(insertBreakAction);
    }

    public void actionPerformed(ActionEvent e) {
      JEditorPane target = getEditor(e);

      if (target != null) {
        if ((!target.isEditable()) || (!target.isEnabled())) {
          UIManager.getLookAndFeel().provideErrorFeedback(target);
          return;
        }
        StyledEditorKit sek = getStyledEditorKit(target);

        if (tempSet != null) {
          tempSet.removeAttributes(tempSet);
        } else {
          tempSet = new SimpleAttributeSet();
        }
        tempSet.addAttributes(sek.getInputAttributes());
        target.replaceSelection("\n");

        MutableAttributeSet ia = sek.getInputAttributes();

        ia.removeAttributes(ia);
        ia.addAttributes(tempSet);
        tempSet.removeAttributes(tempSet);
      } else {
        // See if we are in a JTextComponent.
        JTextComponent text = getTextComponent(e);

        if (text != null) {
          if ((!text.isEditable()) || (!text.isEnabled())) {
            UIManager.getLookAndFeel().provideErrorFeedback(target);
            return;
          }
          text.replaceSelection("\n");
        }
      }
    }
  }
}
